/**
 * Notes: 设备使用订单数据模型 - 宠物门店预约小程序
 * Date: 2025-01-27
 */

const BaseModel = require('./base_model.js');
const timeUtil = require('../../framework/utils/time_util.js');

class DeviceOrderModel extends BaseModel {

	/**
	 * 设备订单状态
	 */
	static STATUS = {
		PENDING_PAY: 101,    // 待支付
		PAID: 201,           // 已支付/使用中
		COMPLETED: 301,      // 已完成
		CANCELLED: 401,      // 已取消
		EXPIRED: 501         // 已过期
	};

	/**
	 * 设备订单状态描述
	 */
	static STATUS_DESC = {
		[DeviceOrderModel.STATUS.PENDING_PAY]: '待支付',
		[DeviceOrderModel.STATUS.PAID]: '使用中',
		[DeviceOrderModel.STATUS.COMPLETED]: '已完成',
		[DeviceOrderModel.STATUS.CANCELLED]: '已取消',
		[DeviceOrderModel.STATUS.EXPIRED]: '已过期'
	};

	/**
	 * 订单类型
	 */
	static ORDER_TYPE = {
		NORMAL: 'normal',    // 正常使用订单
		EXTEND: 'extend'     // 延时订单
	};

	constructor() {
		super();
		this._name = 'ax_device_orders';
	}

	/**
	 * 生成设备订单号
	 * @returns {string} 设备订单号
	 */
	static generateOrderNumber() {
		const now = new Date();
		const year = now.getFullYear();
		const month = String(now.getMonth() + 1).padStart(2, '0');
		const day = String(now.getDate()).padStart(2, '0');
		const random = Math.random().toString(36).substr(2, 6).toUpperCase();
		return `DEV${year}${month}${day}${random}`;
	}

	/**
	 * 创建设备使用订单
	 * @param {Object} data 订单数据
	 * @returns {Object} 创建结果
	 */
	async createOrder(data) {
		const orderData = {
			orderNumber: DeviceOrderModel.generateOrderNumber(),
			userId: data.userId,
			deviceId: data.deviceId,
			storeId: data.storeId,
			orderType: data.orderType || DeviceOrderModel.ORDER_TYPE.NORMAL,
			parentOrderId: data.parentOrderId || '', // 延时订单关联的原订单ID
			duration: data.duration, // 使用时长（分钟）
			pricePerMinute: data.pricePerMinute, // 每分钟价格（分）
			totalAmount: (data.totalAmount != null ? data.totalAmount : data.duration * data.pricePerMinute), // 总金额（分）
			startTime: data.startTime || timeUtil.time(),
			endTime: data.endTime || (timeUtil.time() + data.duration * 60 * 1000),
			status: DeviceOrderModel.STATUS.PENDING_PAY,
			payTime: 0,
			transactionId: '',
			createTime: timeUtil.time(),
			updateTime: timeUtil.time()
		};

		return await DeviceOrderModel.insert(orderData);
	}

	/**
	 * 更新订单状态
	 * @param {string} orderId 订单ID
	 * @param {number} status 新状态
	 * @param {Object} extraData 额外数据
	 * @returns {Object} 更新结果
	 */
	async updateStatus(orderId, status, extraData = {}) {
		const updateData = {
			status: status,
			updateTime: timeUtil.time(),
			...extraData
		};

		return await DeviceOrderModel.edit({ _id: orderId }, updateData);
	}

	/**
	 * 获取用户设备订单列表
	 * @param {string} userId 用户ID
	 * @param {number} page 页码
	 * @param {number} size 每页数量
	 * @returns {Object} 订单列表
	 */
	async getUserOrders(userId, page = 1, size = 20) {
		const where = { userId: userId };
		const orderBy = { createTime: 'desc' };
		
		return await DeviceOrderModel.getList(where, '*', orderBy, page, size, true, 0);
	}

	/**
	 * 获取设备当前使用中的订单
	 * @param {string} deviceId 设备ID
	 * @returns {Object} 订单信息
	 */
	async getDeviceActiveOrder(deviceId) {
		const where = { 
			deviceId: deviceId,
			status: DeviceOrderModel.STATUS.PAID
		};
		
		return await DeviceOrderModel.getOne(where);
	}

	/**
	 * 获取订单详情
	 * @param {string} orderId 订单ID
	 * @param {string} userId 用户ID（可选，用于权限验证）
	 * @returns {Object} 订单详情
	 */
	async getOrderDetail(orderId, userId = null) {
		const where = { _id: orderId };
		if (userId) {
			where.userId = userId;
		}
		
		return await DeviceOrderModel.getOne(where);
	}

	/**
	 * 检查订单是否可以支付
	 * @param {Object} order 订单信息
	 * @returns {boolean} 是否可以支付
	 */
	static canPay(order) {
		return order && order.status === DeviceOrderModel.STATUS.PENDING_PAY;
	}

	/**
	 * 检查订单是否已支付
	 * @param {Object} order 订单信息
	 * @returns {boolean} 是否已支付
	 */
	static isPaid(order) {
		return order && order.status === DeviceOrderModel.STATUS.PAID;
	}

	/**
	 * 获取状态描述
	 * @param {number} status 状态码
	 * @returns {string} 状态描述
	 */
	static getStatusDesc(status) {
		return DeviceOrderModel.STATUS_DESC[status] || '未知状态';
	}

	/**
	 * 检查订单是否已过期
	 * @param {Object} order 订单信息
	 * @returns {boolean} 是否已过期
	 */
	static isExpired(order) {
		if (!order || order.status !== DeviceOrderModel.STATUS.PAID) {
			return false;
		}
		return timeUtil.time() > order.endTime;
	}
}

// 集合名
DeviceOrderModel.CL = "ax_device_orders";

// 数据库结构定义
DeviceOrderModel.DB_STRUCTURE = {
	_pid: 'string|true',
	orderNumber: 'string|true|comment=设备订单号',
	userId: 'string|true|comment=用户ID',
	deviceId: 'string|true|comment=设备ID',
	storeId: 'string|true|comment=门店ID',
	orderType: 'string|true|default=normal|comment=订单类型(normal:正常,extend:延时)',
	parentOrderId: 'string|false|default=|comment=延时订单关联的原订单ID',
	duration: 'int|true|comment=使用时长（分钟）',
	pricePerMinute: 'int|true|comment=每分钟价格（分）',
	totalAmount: 'int|true|comment=总金额（分）',
	startTime: 'int|true|comment=开始时间',
	endTime: 'int|true|comment=结束时间',
	status: 'int|true|default=101|comment=订单状态',
	payTime: 'int|true|default=0|comment=支付时间',
	transactionId: 'string|false|default=|comment=交易ID',
	createTime: 'int|true|comment=创建时间',
	updateTime: 'int|true|comment=更新时间'
};

// 字段前缀
DeviceOrderModel.FIELD_PREFIX = "";

// 禁用自动添加时间和IP字段，使用自定义时间字段
DeviceOrderModel.UPDATE_TIME = false;
DeviceOrderModel.UPDATE_IP = false;
DeviceOrderModel.ADD_ID = false;

module.exports = DeviceOrderModel;